#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<cstring>
#include<unordered_map>
#include<ctype.h>//isspace()
#include<sys/stat.h>//文件权限
#include<fcntl.h>//文件打开标志O_RDDNLY,O_CREAT

#define COMMAND_SIZE 1024
#define FORMAT "[%s@%s %s]# "

//重定向
#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3
//全局变量
int redir = NONE_REDIR;
std::string filename;
//字符处理工具
void TrimSpace(char cmd[], int &end);//清理命令行里的空格

void RedirCheck(char cmd[]);//重定向检测函数声明

//全局数据

//1.命令行参数表
#define MAXARGC 128
char *g_argv[MAXARGC];
int g_argc = 0;

//2.环境变量表
#define MAX_ENV 100
char *g_env[MAX_ENV];
int g_envs = 0;

//3.别名映射表
std::unordered_map<std::string, std::string> alias_list;

//for test
char cwd[1020];
char cwdenv[1024];

//last exit code
int lastcode = 0;

const char *GetUserName()
{
    const char *name = getenv("USER");
    return name == NULL ? "None" : name;
}

const char *GetHostName()
{
    const char *hostname = getenv("HOSTNAME");
    return hostname == NULL ? "None" : hostname;
}

const char *GetPwd()
{
    //const char *pwd = getenv("PWD");
    const char *pwd = getcwd(cwd, sizeof(cwd));//// 获取当前工作目录
    if(pwd != NULL)
    {
        snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);// 生成PWD=xxx格式
        putenv(cwdenv);// 注册为环境变量
    }
    return pwd == NULL ? "None" : pwd;
}

const char *GetHome()
{
    const char *home = getenv("HOME");
    return home == NULL ? "" : home;
}

void InitEnv()
{
    extern char **environ;
    memset(g_env, 0, sizeof(g_env));
    g_envs = 0;
    //从配置文件来
    //1.获取环境变量
    for(int i = 0; environ[i]; i++)
    {
        //1.1申请空间 因为是指针数组，给指针申请空间
        g_env[i] = (char*)malloc(strlen(environ[i])+1);
        strcpy(g_env[i], environ[i]);
        g_envs++;
    }
    g_env[g_envs++] = (char*)"HAHA = for_test";//for test
    g_env[g_envs] = NULL;

    //2.导成环境变量
    for(int i = 0; g_env[i]; i++)
    {
        putenv(g_env[i]);
    }
    environ = g_env;
}

//command
bool Cd()
{
    //cd argc = 1
    if(g_argc == 1)
    {
        std::string home = GetHome();
        if(home.empty()) return true;
        chdir(home.c_str());
    }
    else
    {
        std::string where = g_argv[1];
        //cd - / cd ~
        if(where == "-")
        {
            //Todu
        }
        else if(where == "~")
        {
            //Tpdu
        }
        else
        {
            chdir(where.c_str());
        }
    }
        return true;
}

void Echo()
{
    if(g_argc == 2)
    {
        //echo "hello world"
        //echo $?
        //echo $PAtH
        std::string opt = g_argv[1];
        if(opt == "$?")
        {
            std::cout << lastcode << std:: endl;
            lastcode  = 0;
        }
        else if(opt[0] == '$')
        {
            std::string env_name = opt.substr(1);
            const char* env_value = getenv(env_name.c_str());
            if(env_value)
                std:: cout << env_value << std:: endl;
        
        }
        else
        {
            std::cout << opt << std:: endl;
        }
    }
}

// a/b/c
std::string DirName(const char *pwd)
{
#define SLASH "/"
    std::string dir = pwd;
    if(dir == SLASH) return SLASH;
    auto pos = dir.rfind(SLASH);
    if(pos == std::string::npos) return "BUG?";
    return dir.substr(pos+1);
}


void MakeCommandLine(char cmd_prompt[], int size)
{
    char hostname[256] = {0};
    gethostname(hostname, sizeof(hostname)); // 直接在这获取主机名
    snprintf(cmd_prompt, size, FORMAT, GetUserName(), hostname, GetPwd());

}

void PrintCommandPrompt()
{
    char prompt[COMMAND_SIZE];
    MakeCommandLine(prompt, sizeof(prompt));
    printf("%s", prompt);
    fflush(stdout);
}

bool GetCommandLine(char *out, int size)
{
    //char *c = fgets(out, size, stdin);
    //if(c == NULL) return false;
    //out[strlen(out) - 1] = 0;//清理\n
    //if(strlen(out) == 0) return false;
    //return true;

    char *c = out;
    int len = 0;
    while (true)
    {
        char ch = getchar(); // 逐个字符读取
        if (ch == '\n')      // 换行符表示输入结束
        {
            *c = '\0';
            break;
        }
        else if (ch == 127 || ch == 8) // 退格键（ASCII 127 或 8）
        {
            if (len > 0)
            {
                len--;
                c--;
                printf("\b \b"); // 回退、覆盖、再回退（视觉上删除字符）
            }
        }
        else if (len < size - 1) // 普通字符，且未超出缓冲区
        {
            *c++ = ch;
            len++;
            putchar(ch); // 回显字符
        }
    }
    out[strlen(out)] = 0; // 确保字符串结束
    return len > 0;
}

bool CommandParse(char* commandline)
{
#define SEP " "
    g_argc = 0;
    g_argv[g_argc++] = strtok(commandline, SEP);
    while((bool)(g_argv[g_argc++] = strtok(nullptr, SEP)));
    g_argc--;
    return g_argc > 0 ? true:false;
}

void PrintArgv()
{
    for(int i = 0; g_argv[i]; i++)
    {
        printf("argv[%d]:%s\n", i, g_argv[i]);
    }
    printf("argc: %d\n", g_argc);
}

bool CheckAndExecBuiltin()
{
    std::string cmd = g_argv[0];
    if(cmd == "cd")
    {
        Cd();
        return true;
    }
    else if(cmd == "echo")
    {
        Echo();
        return true;
    }
    else if(cmd == "export")
    {
    }
    else if(cmd == "alias")
    {
       // std::string nickname = g_argv[1];
       // alias_list.insert(k, v);
    }

    return false;
}

//字符处理工具
void TrimSpace(char cmd[], int &end)//清理命令行里的空格
{
    while(isspace(cmd[end]))
    {
        end++;
    }
}

void RedirCheck(char cmd[])//重定向检测函数声明
{
    //1初始化重定向状态
    redir = NONE_REDIR;
    filename.clear();//清空上次文件名

    int start = 0;
    int end = strlen(cmd)-1;

    //2从命令行尾部开始向前遍历，寻找重定向符号
    while(end > start)
    {
        // 情况1：检测到输入重定向（<）：如 "cat < data.txt"
        if(cmd[end] == '<')
        {
            cmd[end++]  = 0;
            TrimSpace(cmd, end);
            redir = INPUT_REDIR;
            filename = cmd + end;
            break;
        }
        else if(cmd[end] == '>')
        {
            //分'>'/'>>'覆盖/追加
            if(cmd[end -1] == '>')
            {
                cmd[end - 1] = 0;
                redir = APPEND_REDIR;
            }
            else
            {
                redir = OUTPUT_REDIR;
            }
            cmd[end++] = 0;
            TrimSpace(cmd, end);
            filename = cmd + end;
            break;
        }
        else
            end--;
    }
}
int Execute()
{
    pid_t id = fork();
    if(id == 0)
    {
        //child
        int fd = -1;//文件描述符
        //根据重定向状态，处理文件打开和标准流替换
        if(redir == INPUT_REDIR)
        {
            // 输入重定向：打开文件为“只读”模式（O_RDONLY）
            fd = open(filename.c_str(), O_RDONLY);
            if(fd < 0) exit(1);
            dup2(fd, 0);
            close(fd);
        }
        else if(redir == OUTPUT_REDIR)
        {
            // 覆盖重定向：打开文件（不存在则创建O_CREAT，只写O_WRONLY，覆盖O_TRUNC）
            // 0666：文件权限（所有者、组、其他用户均有读写权限）
            fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0666);
            if(fd < 0) exit(2);
            dup2(fd, 1);// 替换标准输出（1）：将屏幕输出改为写入fd
            close(fd);
        }
        else if(redir == APPEND_REDIR)
        {
            // 追加重定向：打开文件（创建、只写、追加O_APPEND）
            fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_APPEND, 0666);
            if(fd < 0) exit(2);
            dup2(fd, 1);
            close(fd);
        }
        else
        {}// 无重定向，不处理
           // 2. 进程替换：执行命令（重定向已生效，命令输出/输入会指向目标文件）
        execvp(g_argv[0], g_argv);
        exit(1);
    }
    int status = 0;
    // father
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        lastcode = WEXITSTATUS(status);
    }
    return 0;
}

int main()
{
    // shell 启动的时候，从系统中获取环境变量
    // 我们的环境变量信息应该从父shell统一来
    InitEnv();

    while(true)
    {
        // 1. 输出命令行提示符
        PrintCommandPrompt();

        // 2. 获取用户输入的命令
        char commandline[COMMAND_SIZE];
        if(!GetCommandLine(commandline, sizeof(commandline)))
            continue;

        //3.1检测重定向
        RedirCheck(commandline);//更行redir,filename
                                
        // 3. 命令行分析 "ls -a -l" -> "ls" "-a" "-l"
        if(!CommandParse(commandline))
            continue;
        //PrintArgv();

        // 检测别名
        // 4. 检测并处理内键命令
        if(CheckAndExecBuiltin())
            continue;

        // 5. 执行命令
        Execute();
    }
    //cleanup();
    return 0;
}

































